package tree2;

import static org.junit.Assert.*;

import java.util.ArrayList;
import java.util.Random;

import org.junit.Test;

public class TestingTreeNode {
	@Test
	/** Scenario a
	 * do : make tree
	 * expectation : tree must be neither null nor error
	 */
	public void testTree() {
		Tree tree = new Tree(new Node(new SubNode(5, 1)));
		assertNotNull(tree);
	}

	@Test
	/** Scenario b
	 * do : make tree, search existing value
	 * expectation : tree must be neither null nor error
	 * 				the value is founded
	 */
	public void testSearch() {
		Tree tree = new Tree(new Node(new SubNode(5, 1)));
		assertNotNull(tree);
		assertNotNull("searching ",tree.search(5));
		assertEquals("Value Search", 5,tree.search(5).getSubLeft().getKey());
	}

	@Test
	/** Scenario c
	 * do : make tree, trace existing value
	 * expectation : tree must be neither null nor error
	 * 				the value is founded -> contain the value
	 */
	public void testTrace() {
		Tree tree = new Tree(new Node(new SubNode(5, 1)));
		assertNotNull(tree);
		assertNotNull("tracing ",tree.trace(5));
		assertEquals("Value trace", 5,tree.trace(5).getSubLeft().getKey());
	}
	
	
	@Test
	/**
	 * Scenario-1 (cek state awal)
	 * State >				10 
	 */
	public void testInsert1() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		
		assertEquals("nilai kiri root adalah : ", 10, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("root penuhkah?", false, tree.getRoot().isFull());
	}
		
		
	@Test
	/**Scenario-2 (kasus 0 : root penuh)
	 * State awal > 		10
	 * 
	 * State akhir >   	  5		10
	 * 
	 */
	public void testInsert2() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		
		tree.insert(5,1);
		assertEquals("nilai kiri root adalah : ", 5, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 10, tree.getRoot().getSubRight().getKey());
		assertEquals("root penuhkah?", true, tree.getRoot().isFull());
		}
		
	@Test		
	/**Scenario-3 (kasus 1 : state awal root penuh, ada value baru yang akan diinsert)
	 * State awal > 		10  20
	 * 
	 * State akhir >   	      15
	 * 					10			20
	 */
	public void testInsert3() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
							
		tree.insert(20,1);
		 
		tree.insert(15,1);
		assertEquals("nilai kiri root adalah : ", 15, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 20, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());
}
		
		
	@Test
	/**Scenario-4 (trace 40)
	 * State awal >	   	      20
	 * 					10			30
	 * 
	 * Hasil akhir > 30
	 */
	public void testInsert4() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
								
		tree.insert(20,1);
		tree.insert(30,1);
		
		Node hasiltrace = tree.trace(40);
		assertEquals("nilai kiri hasil trace adalah : ", 30, hasiltrace.getSubLeft().getKey());
		assertEquals("nilai kanan hasil trace adalah : ", null, hasiltrace.getSubRight());
	}
		
		
	@Test
	/**Scenario-5 (kasus 2 : node parent kosong, anak kiri full)
	 *  State awal >    	      	20
	 * 						10 15		30
	 * 
	 * State akhir >    	      	   10 20
	 * 						5 			15			30
	 */ 
	public void testInsert5() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(15,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", 15, tree.getRoot().getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah root adalah : ", 30, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());
		
		tree.insert(5,1);
		assertEquals("nilai kiri root adalah : ", 10, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 20, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 5, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 15, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());
		assertEquals("nilai kiri anak kanan root adalah : ", 30, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());
	}
		
		
	@Test
	/** Scenario-6 (kasus 3 : node parent kosong, anak tengah full)
	 *  State awal >    	      	  20
	 * 						10				25 30
	 * 
	 * State akhir >    	      	  20 30
	 * 						10			25 		40  
	 */ 	      	   
	public void testInsert6() {

		Tree tree = new Tree(new Node(new SubNode(10, 1))); 
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 25, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", 30, tree.getRoot().getNode_middle().getSubRight().getKey());
		
		//tes trace. Node yang seharusnya terambil : 25 30
		Node hasiltrace1 = tree.trace(40);
		assertEquals("nilai kiri hasil trace adalah : ", 25, hasiltrace1.getSubLeft().getKey());
		assertEquals("nilai kanan hasil trace adalah : ", 30, hasiltrace1.getSubRight().getKey());
		
		tree.insert(40,1);
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 25, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());
		assertEquals("nilai kiri anak kanan root adalah : ", 40, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());
	}
		
		
	@Test
	/** Scenario-7 (kasus 4 : node parent penuh, anak kiri full)
	 *  State awal >    	      	  20 30
	 * 						10 15		25 		40
	 *  
	 * 
	 * State akhir >    	      	  20 
	 * 						 10					30
	 * 					  5      15			25 		40
	 */      	   
	public void testInsert7() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", 15, tree.getRoot().getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah root adalah : ", 25, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());
		assertEquals("nilai kiri anak kanan root adalah : ", 40, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());
		
		tree.insert(5,1);
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 30, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_kanan = tree.getRoot().getNode_middle();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 5, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", null, parent_kiri.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 15, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", null, parent_kiri.getNode_middle().getSubRight());

		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 25, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 40, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
	}
		
		 
		
	@Test
	/** Scenario-8 (kasus 4 : node parent penuh, anak tengah full)
	 *  State awal >    	      	  20 30
	 * 						10 15	  25 28 		40
	 *  
	 * 
	 * State akhir >    	      	  26
	 * 					    20    				30
	 * 				  10 15	   25 		    28 		40
	 */ 
	public void testInsert8() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		   	
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", 15, tree.getRoot().getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah root adalah : ", 25, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", 28, tree.getRoot().getNode_middle().getSubRight().getKey());
		assertEquals("nilai kiri anak kanan root adalah : ", 40, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());
		
		tree.insert(26,1); 
		
		assertEquals("nilai kiri root adalah : ", 26, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak kiri root adalah : ", 20, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 30, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_kanan = tree.getRoot().getNode_middle();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 10, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", 15, parent_kiri.getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 25, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", null, parent_kiri.getNode_middle().getSubRight());

		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 28, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 40, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
	} 
		
	@Test
	/** Scenario-9 (kasus 4 : node parent penuh, anak kanan full)
	 *  State awal >    	      	  20 30
	 * 						10 15	  25 28 		40 50
	 *  
	 * 
	 * State akhir >						30
	 * 				    	      20            		45
	 * 						10 15	  25 28 		40 		50
	 */
	public void testInsert9() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		     	   
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", 15, tree.getRoot().getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah root adalah : ", 25, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", 28, tree.getRoot().getNode_middle().getSubRight().getKey());
		assertEquals("nilai kiri anak kanan root adalah : ", 40, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", 50, tree.getRoot().getNode_right().getSubRight().getKey());
		
		tree.insert(45,1); 
		
		assertEquals("nilai kiri root adalah : ", 30, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", null, tree.getRoot().getSubRight());
		assertEquals("nilai kiri anak kiri root adalah : ", 20, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 45, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_kanan = tree.getRoot().getNode_middle();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 10, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", 15, parent_kiri.getNode_left().getSubRight().getKey());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 25, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", 28, parent_kiri.getNode_middle().getSubRight().getKey());

		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 40, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 50, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
		
	}
		
	@Test
	/** Scenario-10 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45
	 * 					10 15	  25 		28 			40 		50
	 *  
	 * State akhir >							20 30
	 * 				    	      10 					27         				45
	 * 						5 			15	  		25 		28 				40 		50
	 */
	public void testInsert10() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(5,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 10, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 27, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		assertEquals("nilai kiri anak kanan root adalah : ", 45, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_tengah = tree.getRoot().getNode_middle();
		Node parent_kanan = tree.getRoot().getNode_right();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 5, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", null, parent_kiri.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 15, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", null, parent_kiri.getNode_middle().getSubRight());

		assertEquals("nilai kiri anak kiri dari parent_tengah adalah : ", 25, parent_tengah.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_tengah adalah : ", null, parent_tengah.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_tengah adalah : ", 28, parent_tengah.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_tengah adalah : ", null, parent_tengah.getNode_middle().getSubRight());
		
		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 40, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 50, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
		
		//tree.print2(tree.getRoot());
	}
		
	@Test
	/** Scenario-11 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45
	 * 					10 15	  25 		28 			40 		50
	 *  
	 * State akhir >									20 30
	 * 				    	      11 					27         				45
	 * 						10 			15	  		25 		28 				40 		50
	 */
	public void testInsert11() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(11,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 11, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 27, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		assertEquals("nilai kiri anak kanan root adalah : ", 45, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_tengah = tree.getRoot().getNode_middle();
		Node parent_kanan = tree.getRoot().getNode_right();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 10, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", null, parent_kiri.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 15, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", null, parent_kiri.getNode_middle().getSubRight());

		assertEquals("nilai kiri anak kiri dari parent_tengah adalah : ", 25, parent_tengah.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_tengah adalah : ", null, parent_tengah.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_tengah adalah : ", 28, parent_tengah.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_tengah adalah : ", null, parent_tengah.getNode_middle().getSubRight());
		
		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 40, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 50, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
	}
		
	@Test
	/** Scenario-12 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45
	 * 					10 15	  25 		28 			40 		50
	 *  
	 * State akhir >									20 30
	 * 				    	      15 					27         				45
	 * 						10 			16	  		25 		28 				40 		50
	 */
	public void testInsert12() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(16,1);
		
		assertEquals("nilai kiri root adalah : ", 20, tree.getRoot().getSubLeft().getKey());
		assertEquals("nilai kanan root adalah : ", 30, tree.getRoot().getSubRight().getKey());
		assertEquals("nilai kiri anak kiri root adalah : ", 15, tree.getRoot().getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri root adalah : ", null, tree.getRoot().getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah root adalah : ", 27, tree.getRoot().getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah root adalah : ", null, tree.getRoot().getNode_middle().getSubRight());		
		assertEquals("nilai kiri anak kanan root adalah : ", 45, tree.getRoot().getNode_right().getSubLeft().getKey());
		assertEquals("nilai kanan anak kanan root adalah : ", null, tree.getRoot().getNode_right().getSubRight());		
		
		Node parent_kiri = tree.getRoot().getNode_left();
		Node parent_tengah = tree.getRoot().getNode_middle();
		Node parent_kanan = tree.getRoot().getNode_right();
		
		assertEquals("nilai kiri anak kiri dari parent_kiri adalah : ", 10, parent_kiri.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kiri adalah : ", null, parent_kiri.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kiri adalah : ", 16, parent_kiri.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kiri adalah : ", null, parent_kiri.getNode_middle().getSubRight());

		assertEquals("nilai kiri anak kiri dari parent_tengah adalah : ", 25, parent_tengah.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_tengah adalah : ", null, parent_tengah.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_tengah adalah : ", 28, parent_tengah.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_tengah adalah : ", null, parent_tengah.getNode_middle().getSubRight());
		
		assertEquals("nilai kiri anak kiri dari parent_kanan adalah : ", 40, parent_kanan.getNode_left().getSubLeft().getKey());
		assertEquals("nilai kanan anak kiri dari parent_kanan adalah : ", null, parent_kanan.getNode_left().getSubRight());
		assertEquals("nilai kiri anak tengah dari parent_kanan adalah : ", 50, parent_kanan.getNode_middle().getSubLeft().getKey());
		assertEquals("nilai kanan anak tengah dari parent_kanan adalah : ", null, parent_kanan.getNode_middle().getSubRight());
	}
		
	@Test
	/** Scenario-13 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45 100
	 * 					10 15	  25 		28 		40 		50 60		200
	 *  
	 * State akhir >										30 55
	 * 				    	      20 27         			45 				100
	 * 					10 15	  25 		28 			40 		50 		60		200
	 */
	public void testInsert13() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(100,1);
		tree.insert(200,1);
		tree.insert(60,1);
		tree.insert(55,1);
		
		tree.print2(tree.getRoot());
	}
		
	@Test
	/** Skenario-14 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45 100
	 * 					10 15	  25 		28 		40 		50 60		200
	 *  
	 * State akhir >							30 60
	 * 				    	      20 27         			45 				100
	 * 					10 15	  25 		28 			40 		50 		61		200
	 */
	public void testInsert14() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(100,1);
		tree.insert(200,1);
		tree.insert(60,1);
		tree.insert(61,1);
		
		tree.print2(tree.getRoot());
	}
		
	@Test
	/** Scenario-15 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >								30
	 * 				    	      20 27         			45 100
	 * 					10 15	  25 		28 		40 		50 60		200 201
	 *  
	 * State akhir >									30 100
	 * 				    	      20 27         		45 					201
	 * 					10 15	  25 		28 		40 		50 60		200 	202					
	 */
	public void testInsert15() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		  
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(100,1);
		tree.insert(200,1);
		tree.insert(60,1);
		tree.insert(201,1);
		tree.insert(202,1);
		
		tree.print2(tree.getRoot());
	}
		
	@Test
	/** Skenario-16 (kasus loop : anak root penuh, anak kiri anak kiri root penuh juga)
	 * State awal >									30 100
	 * 				    	      20 27         		45 					201
	 * 					10 15	  25 		28 		40 		50 60		200 	202	
	 *  
	 * State akhir >								30
	 * 								20 								100		
	 *  					10 				27 				45 				201
	 * 					 5     15 		25     28 		40    50|60 	200     202
	 */
	public void testInsert16() {

		Tree tree = new Tree(new Node(new SubNode(10, 1)));
		 
		tree.insert(20,1);
		tree.insert(30,1);
		tree.insert(25,1);
		tree.insert(40,1);
		tree.insert(15,1);
		tree.insert(28,1);
		tree.insert(50,1);
		tree.insert(45,1);
		tree.insert(27,1);
		tree.insert(100,1);
		tree.insert(200,1);
		tree.insert(60,1);
		tree.insert(201,1);
		tree.insert(202,1);
		tree.insert(5,1);
		
		tree.print2(tree.getRoot());
	}
		
	@Test
	/** Skenario-lalala
	 */
	public void testInsertLala() {

		Tree tree = new Tree(new Node(new SubNode(10, 1))); 
		tree.insert(66,1);
		tree.insert(3,1);
		tree.insert(20,1);
		tree.insert(51,1);
		tree.insert(85,1);
		tree.insert(91,1);
		tree.insert(2,1);
		tree.insert(8,1);
		tree.insert(9,1);
		tree.insert(35,1);
		tree.insert(43,1);
		tree.insert(48,1);
		tree.insert(60,1);
		tree.insert(69,1);
		tree.insert(86,1);
		tree.insert(92,1);
		tree.insert(93,1);
		
		tree.print2(tree.getRoot());
		 
	}
	
	@Test
	/** Skenario-lalala
	 */
	public void testPostingList() {

		Tree tree = new Tree(new Node(new SubNode(10, 1))); 
		tree.insert(66,1);
		tree.insert(66, 1);
		tree.insert(66, 2);
		
		tree.print2(tree.getRoot());
		 
	}
	
	//@Test
	public void testing() {
		//testing
		Tree ob = new Tree(new Node(new SubNode(10, 1)));
		Random rand = new Random(10000000);
		for (int i=1;i<=1000000;i++){
//			ob.insert(i);
			ob.insert(rand.nextInt(),1);
		}
//		System.out.println("Jumlah yang diinsert 2-3 tree : "+ob.getJumVal());
		
		//uncomment this to acivated save and load to file
//		Tree.save(ob, "23tree1.txt");
//		Tree test =	(Tree) Tree.load("23tree1.txt");
		
		int k = 0;
		for (int j=1;j<=100000;j++){
//			ob.search(j);
			ob.search(rand.nextInt());
			k++;
		}
//		System.out.println("Jumlah yang disearch 2-3 tree : "+k);
	}
	
	
	//@Test
	public void testingSeq() {
		ArrayList<Integer> testArray = new ArrayList<Integer>();
		Random rand = new Random(10000000);
		int k = 0;
		for (int i=1;i<=1000000;i++){
			int l = rand.nextInt();
			
			if(!testArray.contains(l)){
				testArray.add(l);
				k++;
			}
		}
		System.out.println("Jumlah yang diinsert seq arraylist : "+k);
		
		//uncomment this to acivated save and load to file
//		Tree.save(testArray, "seq1.txt");
//		ArrayList<Integer> testSeq = (ArrayList<Integer>) Tree.load("seq1.txt");
		
		int f = 0;
		int ketemuu = 0;
		for (int j=1;j<=100000;j++){
			f++;
			int s = rand.nextInt();
			if(testArray.contains(s)){
				ketemuu++;
			}

		}
		System.out.println("Jumlah yang disearch seq arraylist : "+f);
		System.out.println("Jumlah value yang ketemu : "+ketemuu);
	}
}
